

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>Low-level system routines &mdash; quippy 7ea04c5+ documentation</title>
  

  
  
    <link rel="shortcut icon" href="_static/favicon.ico"/>
  
  
  

  
  <script type="text/javascript" src="_static/js/modernizr.min.js"></script>
  
    
      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
        <script type="text/javascript" src="_static/jquery.js"></script>
        <script type="text/javascript" src="_static/underscore.js"></script>
        <script type="text/javascript" src="_static/doctools.js"></script>
        <script type="text/javascript" src="_static/language_data.js"></script>
        <script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"processClass": "math|output_area", "processEscapes": true, "ignoreClass": "document", "inlineMath": [["$", "$"], ["\\(", "\\)"]]}})</script>
    
    <script type="text/javascript" src="_static/js/theme.js"></script>

    

  
  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
  <link rel="stylesheet" href="_static/theme_overrides.css" type="text/css" />
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="prev" title="Units and physical constants" href="units.html" /> 
</head>

<body class="wy-body-for-nav">

   
  <div class="wy-grid-for-nav">
    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search" >
          

          
            <a href="index.html" class="icon icon-home"> quippy
          

          
            
            <img src="_static/hybrid.png" class="logo" alt="Logo"/>
          
          </a>

          
            
            
              <div class="version">
                7ea04c5+
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
    
            
            
              
            
            
              <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="intro.html">Introduction to <code class="docutils literal notranslate"><span class="pre">quippy</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="install.html">Installation of QUIP and quippy</a></li>
<li class="toctree-l1"><a class="reference internal" href="Tutorials/index.html">Tutorials</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="quippy.html">Quippy library reference</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="quippy.html#core-functionality">Core functionality</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#structure-generation-manipulation-and-analysis">Structure generation, manipulation and analysis</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#molecular-dynamics">Molecular Dynamics</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#additional-tools-for-potentials">Additional tools for Potentials</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#mathematical-and-optimisation-tools">Mathematical and optimisation tools</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#units-data-and-constants">Units, Data and Constants</a></li>
<li class="toctree-l2 current"><a class="reference internal" href="quippy.html#low-level-routines-and-datatypes">Low level routines and datatypes</a><ul class="current">
<li class="toctree-l3 current"><a class="current reference internal" href="#">Low-level system routines</a><ul class="simple">
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="connection.html">Connection objects</a></li>
<li class="toctree-l3"><a class="reference internal" href="dictionary.html">Fortran Dictionary objects for storing key/value pairs</a></li>
<li class="toctree-l3"><a class="reference internal" href="domaindecomposition.html">DomainDecomposition objects</a></li>
<li class="toctree-l3"><a class="reference internal" href="table.html">Fortran <code class="docutils literal notranslate"><span class="pre">Table</span></code> for dynamically extendable arrays</a></li>
<li class="toctree-l3"><a class="reference internal" href="mpi_context.html">MPI parallel interface</a></li>
<li class="toctree-l3"><a class="reference internal" href="paramreader.html">Command line argument parser</a></li>
<li class="toctree-l3"><a class="reference internal" href="fortranio.html">Fortran input/output</a></li>
<li class="toctree-l3"><a class="reference internal" href="farray.html">FortranArray objects for one-based array indexing</a></li>
<li class="toctree-l3"><a class="reference internal" href="util.html">Utility functions</a></li>
<li class="toctree-l3"><a class="reference internal" href="qpxml.html">GAP XML functions</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="visualisation.html">Visualisation Tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="fortran_wrapper.html">Appendix: wrapping Fortran 90 Code</a></li>
<li class="toctree-l1"><a class="reference internal" href="teach_sparse.html">Command line options of the teach_sparse main program</a></li>
</ul>

            
          
    <p></p>
    <ul>
        <li><a href="genindex.html">Index</a></li>
        <li><a href="py-modindex.html">Module Index</a></li>
        <li><a href="search.html">Search Page</a></li>
        <li><a href="_modules/index.html">Module Source Code</a></li>
    </ul>
  
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="index.html">quippy</a>
        
      </nav>


      <div class="wy-nav-content">
        
        <div class="rst-content">
        
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="index.html">Docs</a> &raquo;</li>
        
          <li><a href="quippy.html">Quippy library reference</a> &raquo;</li>
        
      <li>Low-level system routines</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/system.rst.txt" rel="nofollow"> View page source</a>
          
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  
<style>
/* CSS overrides for sphinx_rtd_theme */

/* 24px margin */
.nbinput.nblast,
.nboutput.nblast {
    margin-bottom: 19px;  /* padding has already 5px */
}

/* ... except between code cells! */
.nblast + .nbinput {
    margin-top: -19px;
}

.admonition > p:before {
    margin-right: 4px;  /* make room for the exclamation icon */
}

/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
    text-align: unset;
}
</style>
<div class="section" id="module-quippy.system">
<span id="low-level-system-routines"></span><h1>Low-level system routines<a class="headerlink" href="#module-quippy.system" title="Permalink to this headline">¶</a></h1>
<p>The system module contains low-level routines for I/O, timing, random
number generation etc. The Inoutput type is used to abstract both
formatted and unformatted (i.e. binary) I/O.</p>
<p>Module contents for <a class="reference internal" href="#module-quippy.system" title="quippy.system: Low-level routines"><code class="xref py py-mod docutils literal notranslate"><span class="pre">quippy.system</span></code></a>:</p>
<p class="rubric">Classes</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-obj docutils literal notranslate"><span class="pre">InOutput</span></code></a>(…)</td>
<td>Open a file for reading or writing.</td>
</tr>
</tbody>
</table>
<p class="rubric">Functions</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.find_closing_delimiter" title="quippy.system.find_closing_delimiter"><code class="xref py py-obj docutils literal notranslate"><span class="pre">find_closing_delimiter</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.pick_up_unit" title="quippy.system.pick_up_unit"><code class="xref py py-obj docutils literal notranslate"><span class="pre">pick_up_unit</span></code></a>()</td>
<td>OMIT</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.system_resync_rng" title="quippy.system.system_resync_rng"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_resync_rng</span></code></a>()</td>
<td><p class="rubric">References</p>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.upper_case" title="quippy.system.upper_case"><code class="xref py py-obj docutils literal notranslate"><span class="pre">upper_case</span></code></a>(word)</td>
<td>Convert a word to upper case</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.get_mpi_size_rank" title="quippy.system.get_mpi_size_rank"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_mpi_size_rank</span></code></a>(comm)</td>
<td>Return the mpi size and rank for the communicator <code class="docutils literal notranslate"><span class="pre">comm</span></code>.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_timer" title="quippy.system.system_timer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_timer</span></code></a>(…)</td>
<td>Measure elapsed CPU and wall clock time between pairs of calls with matching <code class="docutils literal notranslate"><span class="pre">name</span></code> parameter.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.verbosity_of_str" title="quippy.system.verbosity_of_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_of_str</span></code></a>(str)</td>
<td>Map from descriptive verbosity names (<code class="docutils literal notranslate"><span class="pre">NORMAL</span></code>, <code class="docutils literal notranslate"><span class="pre">VERBOSE</span></code> etc.) to numbers</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.reference_true" title="quippy.system.reference_true"><code class="xref py py-obj docutils literal notranslate"><span class="pre">reference_true</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.th" title="quippy.system.th"><code class="xref py py-obj docutils literal notranslate"><span class="pre">th</span></code></a>(n)</td>
<td>Return the correct ordinal ending (st,nd,rd,th) for the given integer</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.next_non_separator" title="quippy.system.next_non_separator"><code class="xref py py-obj docutils literal notranslate"><span class="pre">next_non_separator</span></code></a>(start,end,separators)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.hello_world" title="quippy.system.hello_world"><code class="xref py py-obj docutils literal notranslate"><span class="pre">hello_world</span></code></a>([seed,common_seed])</td>
<td>Called by <code class="docutils literal notranslate"><span class="pre">system_initialise</span></code> to print welcome messages and seed the random number generator.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.get_env_var" title="quippy.system.get_env_var"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_env_var</span></code></a>(name,[status])</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.ran_exp" title="quippy.system.ran_exp"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ran_exp</span></code></a>()</td>
<td>Return a random real distributed exponentially between zero and positive infinity with mean and variance of unity</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.parse_string" title="quippy.system.parse_string"><code class="xref py py-obj docutils literal notranslate"><span class="pre">parse_string</span></code></a>(delimiters,fields,[matching,error])</td>
<td>outdated - please use split_string Parse a string into fields delimited by certain characters.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.parse_string_orig" title="quippy.system.parse_string_orig"><code class="xref py py-obj docutils literal notranslate"><span class="pre">parse_string_orig</span></code></a>(delimiters,fields)</td>
<td>Parse a string into fields delimited by certain characters.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_initialise" title="quippy.system.system_initialise"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_initialise</span></code></a>(…)</td>
<td>Must be called at the start of all programs.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.verbosity_pop" title="quippy.system.verbosity_pop"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_pop</span></code></a>()</td>
<td>pop the current verbosity value off the stack</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.get_quippy_running" title="quippy.system.get_quippy_running"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_quippy_running</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.round" title="quippy.system.round"><code class="xref py py-obj docutils literal notranslate"><span class="pre">round</span></code></a>(r,digits)</td>
<td>Concatenation functions.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_get_random_seed" title="quippy.system.system_get_random_seed"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_get_random_seed</span></code></a>()</td>
<td>Return the current random number seed.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.set_timing" title="quippy.system.set_timing"><code class="xref py py-obj docutils literal notranslate"><span class="pre">set_timing</span></code></a>(do_timing)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.real_sci_format_length" title="quippy.system.real_sci_format_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">real_sci_format_length</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.enable_timing" title="quippy.system.enable_timing"><code class="xref py py-obj docutils literal notranslate"><span class="pre">enable_timing</span></code></a>()</td>
<td><p class="rubric">References</p>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.mem_info" title="quippy.system.mem_info"><code class="xref py py-obj docutils literal notranslate"><span class="pre">mem_info</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.link_run_directory" title="quippy.system.link_run_directory"><code class="xref py py-obj docutils literal notranslate"><span class="pre">link_run_directory</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.ran_uniform" title="quippy.system.ran_uniform"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ran_uniform</span></code></a>()</td>
<td>Return a random real number uniformly distributed in the range [0,1]</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.mpi_id" title="quippy.system.mpi_id"><code class="xref py py-obj docutils literal notranslate"><span class="pre">mpi_id</span></code></a>()</td>
<td>Return this processes’ MPI ID</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.progress" title="quippy.system.progress"><code class="xref py py-obj docutils literal notranslate"><span class="pre">progress</span></code></a>(total,current,name)</td>
<td>Print a progress bar</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.linebreak_string" title="quippy.system.linebreak_string"><code class="xref py py-obj docutils literal notranslate"><span class="pre">linebreak_string</span></code></a>(str,line_len)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_finalise" title="quippy.system.system_finalise"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_finalise</span></code></a>()</td>
<td>Shut down gracefully, finalising system objects.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.print_title" title="quippy.system.print_title"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_title</span></code></a>(title,[verbosity])</td>
<td>Print a centred title, like this:</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.wait_for_file_to_exist" title="quippy.system.wait_for_file_to_exist"><code class="xref py py-obj docutils literal notranslate"><span class="pre">wait_for_file_to_exist</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.string_to_logical" title="quippy.system.string_to_logical"><code class="xref py py-obj docutils literal notranslate"><span class="pre">string_to_logical</span></code></a>(string,[error])</td>
<td>Convert an input string into a logical.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.split_string" title="quippy.system.split_string"><code class="xref py py-obj docutils literal notranslate"><span class="pre">split_string</span></code></a>(separators,quotes,fields,[matching])</td>
<td>split a string at separators, making sure not to break up bits that are in quotes (possibly matching opening and closing quotes), and also strip one level of quotes off, sort of like a shell would when tokenizing</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.verbosity_to_str" title="quippy.system.verbosity_to_str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_to_str</span></code></a>(val)</td>
<td>Map from verbsoity codes to descriptive strings</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.string_to_int" title="quippy.system.string_to_int"><code class="xref py py-obj docutils literal notranslate"><span class="pre">string_to_int</span></code></a>(string,[error])</td>
<td>Convert an input string into an integer.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.real_format_length" title="quippy.system.real_format_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">real_format_length</span></code></a>(r)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.alloc_trace" title="quippy.system.alloc_trace"><code class="xref py py-obj docutils literal notranslate"><span class="pre">alloc_trace</span></code></a>(str,amt)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.parallel_print" title="quippy.system.parallel_print"><code class="xref py py-obj docutils literal notranslate"><span class="pre">parallel_print</span></code></a>(lines,comm,[verbosity,file])</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.verbosity_set_minimum" title="quippy.system.verbosity_set_minimum"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_set_minimum</span></code></a>(verbosity)</td>
<td>set the minimum verbosity value, by pushing value onto stack and pushing 1 on to verbosity_cascade_stack</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.current_version" title="quippy.system.current_version"><code class="xref py py-obj docutils literal notranslate"><span class="pre">current_version</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.increase_stack" title="quippy.system.increase_stack"><code class="xref py py-obj docutils literal notranslate"><span class="pre">increase_stack</span></code></a>(stack_size)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.current_verbosity" title="quippy.system.current_verbosity"><code class="xref py py-obj docutils literal notranslate"><span class="pre">current_verbosity</span></code></a>()</td>
<td>return the current value of verbosity</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.verbosity_push_decrement" title="quippy.system.verbosity_push_decrement"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_push_decrement</span></code></a>([n])</td>
<td>push the current value - n onto the stack</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.progress_timer" title="quippy.system.progress_timer"><code class="xref py py-obj docutils literal notranslate"><span class="pre">progress_timer</span></code></a>(…)</td>
<td>Print a progress bar with an estimate of time to completion based on the elapsed time so far</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.reference_false" title="quippy.system.reference_false"><code class="xref py py-obj docutils literal notranslate"><span class="pre">reference_false</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.cmd_arg_count" title="quippy.system.cmd_arg_count"><code class="xref py py-obj docutils literal notranslate"><span class="pre">cmd_arg_count</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.abort_on_mpi_error" title="quippy.system.abort_on_mpi_error"><code class="xref py py-obj docutils literal notranslate"><span class="pre">abort_on_mpi_error</span></code></a>(error_code,routine_name)</td>
<td>Abort with a useful message if an MPI routine returned an error status</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.linebreak_string_length" title="quippy.system.linebreak_string_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">linebreak_string_length</span></code></a>(str,line_len)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.print_warning" title="quippy.system.print_warning"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_warning</span></code></a>(message)</td>
<td>Print a warning message to log</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.get_cmd_arg" title="quippy.system.get_cmd_arg"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_cmd_arg</span></code></a>(i,[status])</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.ran_string" title="quippy.system.ran_string"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ran_string</span></code></a>(l)</td>
<td>Return a random string of length l containing the characters A-Z, a-z, and 0-9</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.verbosity_unset_minimum" title="quippy.system.verbosity_unset_minimum"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_unset_minimum</span></code></a>()</td>
<td>unset the minimum verbosity value, by popping value from stack and popping from verbosity_cascade_stack</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.get_mainlog_errorlog_ptr" title="quippy.system.get_mainlog_errorlog_ptr"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_mainlog_errorlog_ptr</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.verbosity_push_increment" title="quippy.system.verbosity_push_increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_push_increment</span></code></a>([n])</td>
<td>push the current value + n onto the stack</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_reseed_rng" title="quippy.system.system_reseed_rng"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_reseed_rng</span></code></a>(new_seed)</td>
<td>Reseed the random number generator.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.mpi_n_procs" title="quippy.system.mpi_n_procs"><code class="xref py py-obj docutils literal notranslate"><span class="pre">mpi_n_procs</span></code></a>()</td>
<td>Return the total number of MPI processes.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.ran" title="quippy.system.ran"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ran</span></code></a>()</td>
<td>Return a random integer</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.lower_case" title="quippy.system.lower_case"><code class="xref py py-obj docutils literal notranslate"><span class="pre">lower_case</span></code></a>(word)</td>
<td>Convert a word to lower case</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.system_set_random_seeds" title="quippy.system.system_set_random_seeds"><code class="xref py py-obj docutils literal notranslate"><span class="pre">system_set_random_seeds</span></code></a>(seed)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.s2a" title="quippy.system.s2a"><code class="xref py py-obj docutils literal notranslate"><span class="pre">s2a</span></code></a>(s)</td>
<td>String to character array</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.verbosity_push" title="quippy.system.verbosity_push"><code class="xref py py-obj docutils literal notranslate"><span class="pre">verbosity_push</span></code></a>(val)</td>
<td>Push a value onto the verbosity stack Don’t ever lower the verbosity if verbosity minimum is set,   but always push _something_</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.int_format_length" title="quippy.system.int_format_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">int_format_length</span></code></a>(i)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.pad" title="quippy.system.pad"><code class="xref py py-obj docutils literal notranslate"><span class="pre">pad</span></code></a>(s,l,n0)</td>
<td>String to padded character array of length l</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.dealloc_trace" title="quippy.system.dealloc_trace"><code class="xref py py-obj docutils literal notranslate"><span class="pre">dealloc_trace</span></code></a>(str,amt)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.string_to_real" title="quippy.system.string_to_real"><code class="xref py py-obj docutils literal notranslate"><span class="pre">string_to_real</span></code></a>(string,[error])</td>
<td>Convert an input string into a real.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.a2s" title="quippy.system.a2s"><code class="xref py py-obj docutils literal notranslate"><span class="pre">a2s</span></code></a>(a)</td>
<td>Character array to string</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.date_and_time_string" title="quippy.system.date_and_time_string"><code class="xref py py-obj docutils literal notranslate"><span class="pre">date_and_time_string</span></code></a>(values)</td>
<td>Take the values from <code class="docutils literal notranslate"><span class="pre">date_and_time</span></code> and make a nice string</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.get_timing" title="quippy.system.get_timing"><code class="xref py py-obj docutils literal notranslate"><span class="pre">get_timing</span></code></a>()</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.disable_timing" title="quippy.system.disable_timing"><code class="xref py py-obj docutils literal notranslate"><span class="pre">disable_timing</span></code></a>()</td>
<td><p class="rubric">References</p>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.split_string_simple" title="quippy.system.split_string_simple"><code class="xref py py-obj docutils literal notranslate"><span class="pre">split_string_simple</span></code></a>(str,separators,n0,[error])</td>
<td>split a string into fields separated by possible separators no quoting, matching separators, just a simple split</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.is_file_readable" title="quippy.system.is_file_readable"><code class="xref py py-obj docutils literal notranslate"><span class="pre">is_file_readable</span></code></a>(filename)</td>
<td>Test if the file <code class="docutils literal notranslate"><span class="pre">filename</span></code> can be accessed.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.current_times" title="quippy.system.current_times"><code class="xref py py-obj docutils literal notranslate"><span class="pre">current_times</span></code></a>([cpu_t,wall_t,mpi_t])</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.ran_normal" title="quippy.system.ran_normal"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ran_normal</span></code></a>()</td>
<td>Return random real from Normal distribution with mean zero and standard deviation one.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.make_run_directory" title="quippy.system.make_run_directory"><code class="xref py py-obj docutils literal notranslate"><span class="pre">make_run_directory</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.optional_default" title="quippy.system.optional_default"><code class="xref py py-obj docutils literal notranslate"><span class="pre">optional_default</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>takes as arguments a default value and an optional argument, and returns the optional argument value if it’s present, otherwise the default value</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.string_to_numerical" title="quippy.system.string_to_numerical"><code class="xref py py-obj docutils literal notranslate"><span class="pre">string_to_numerical</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Routine is wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">string_to_numerical</span></code> containing multiple routines:</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.print_" title="quippy.system.print_"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Overloaded interface for printing.</td>
</tr>
</tbody>
</table>
<p class="rubric">Attributes</p>
<table border="1" class="docutils">
<colgroup>
<col width="71%" />
<col width="29%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Value</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">qp</span></code></td>
<td>8</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">INOUT</span></code></td>
<td>2</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_NERD</span></code></td>
<td>1000</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">COMPLEX_SIZE</span></code></td>
<td>16</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_NORMAL</span></code></td>
<td>0</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">REAL_SIZE</span></code></td>
<td>8</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">ran_Q</span></code></td>
<td>127773</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_VERBOSE</span></code></td>
<td>1</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_ANAL</span></code></td>
<td>10000</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">ran_M</span></code></td>
<td>2147483647</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">INTEGER_SIZE</span></code></td>
<td>4</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">ran_R</span></code></td>
<td>2836</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">NUMERICAL_ZERO</span></code></td>
<td>1e-14</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">ran_A</span></code></td>
<td>16807</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">MAX_READABLE_ARGS</span></code></td>
<td>100</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">OUTPUT</span></code></td>
<td>1</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_SILENT</span></code></td>
<td>-1</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">INPUT</span></code></td>
<td>0</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">PRINT_ALWAYS</span></code></td>
<td>-100000</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">dp</span></code></td>
<td>8</td>
</tr>
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">TIMER_STACK</span></code></td>
<td>500</td>
</tr>
</tbody>
</table>
<dl class="class">
<dt id="quippy.system.InOutput">
<em class="property">class </em><code class="descclassname">quippy.system.</code><code class="descname">InOutput</code><span class="sig-paren">(</span><span class="optional">[</span><em>filename</em>, <em>action</em>, <em>isformatted</em>, <em>append</em>, <em>verbosity</em>, <em>verbosity_cascade</em>, <em>master_only</em>, <em>unit</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="oo_fortran.html#quippy.oo_fortran.FortranDerivedType" title="quippy.oo_fortran.FortranDerivedType"><code class="xref py py-class docutils literal notranslate"><span class="pre">quippy.oo_fortran.FortranDerivedType</span></code></a></p>
<p>Open a file for reading or writing. The action optional parameter can
be one of <code class="docutils literal notranslate"><span class="pre">INPUT</span></code> (default), <code class="docutils literal notranslate"><span class="pre">OUTPUT</span></code> or <code class="docutils literal notranslate"><span class="pre">INOUT</span></code>.
For unformatted output, the
<code class="docutils literal notranslate"><span class="pre">isformatted</span></code> optional parameter must
be set to false.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>filename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>action</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>isformatted</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>append</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>verbosity_cascade</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>master_only</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>unit</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">__init__initialise</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.
Class is wrapper around Fortran type <code class="docutils literal notranslate"><span class="pre">InOutput</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Attributes:</th><td class="field-body"><dl class="first last docutils">
<dt><a class="reference internal" href="#quippy.system.InOutput.active" title="quippy.system.InOutput.active"><code class="xref py py-obj docutils literal notranslate"><span class="pre">active</span></code></a></dt>
<dd><p class="first last">Does it print?</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.activate" title="quippy.system.InOutput.activate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">activate</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>inoutput_activate</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.InOutput.backspace" title="quippy.system.InOutput.backspace"><code class="xref py py-obj docutils literal notranslate"><span class="pre">backspace</span></code></a>([n])</td>
<td>Move the file pointer back by <code class="docutils literal notranslate"><span class="pre">n</span></code> (defaults to 1) records.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.close" title="quippy.system.InOutput.close"><code class="xref py py-obj docutils literal notranslate"><span class="pre">close</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Close file but don’t finalise this Inoutput</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.InOutput.deactivate" title="quippy.system.InOutput.deactivate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">deactivate</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>inoutput_deactivate</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.do_output" title="quippy.system.InOutput.do_output"><code class="xref py py-obj docutils literal notranslate"><span class="pre">do_output</span></code></a>(*args,&nbsp;**kwargs)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">is_same_fortran_object</span></code>(other)</td>
<td>Test if <cite>self</cite> and <cite>other</cite> point to the same Fortan object.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.mpi_all_inoutput" title="quippy.system.InOutput.mpi_all_inoutput"><code class="xref py py-obj docutils literal notranslate"><span class="pre">mpi_all_inoutput</span></code></a>([value])</td>
<td>inoutput_mpi_all_inoutput([value])</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.InOutput.parse_line" title="quippy.system.InOutput.parse_line"><code class="xref py py-obj docutils literal notranslate"><span class="pre">parse_line</span></code></a>(delimiters,fields,[status])</td>
<td>Call parse_string on the next line from a file</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.print_mem_info" title="quippy.system.InOutput.print_mem_info"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_mem_info</span></code></a>([file])</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.InOutput.print_mpi_id" title="quippy.system.InOutput.print_mpi_id"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_mpi_id</span></code></a>([value])</td>
<td>inoutput_print_mpi_id([value])</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.read_ascii" title="quippy.system.InOutput.read_ascii"><code class="xref py py-obj docutils literal notranslate"><span class="pre">read_ascii</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">read_ascii</span></code> containing multiple routines:</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.system.InOutput.read_line" title="quippy.system.InOutput.read_line"><code class="xref py py-obj docutils literal notranslate"><span class="pre">read_line</span></code></a>([status])</td>
<td>Read a line of text from a file (up to a line break, or 1024 characters).</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.system.InOutput.rewind" title="quippy.system.InOutput.rewind"><code class="xref py py-obj docutils literal notranslate"><span class="pre">rewind</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Rewind to the start of this file.</td>
</tr>
<tr class="row-even"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">shallow_copy</span></code>()</td>
<td>Return a shallow copy of <cite>self</cite>.</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">shallow_copy_from</span></code>(other)</td>
<td>Transform <cite>self</cite> into a shallow copy of <cite>other</cite>.</td>
</tr>
</tbody>
</table>
<dl class="method">
<dt id="quippy.system.InOutput.activate">
<code class="descname">activate</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.activate" title="Permalink to this definition">¶</a></dt>
<dd><p>inoutput_activate</p>
<p>Activate an Inoutput object temporarily.</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">activate</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.backspace">
<code class="descname">backspace</code><span class="sig-paren">(</span><span class="optional">[</span><em>n</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.backspace" title="Permalink to this definition">¶</a></dt>
<dd><p>Move the file pointer back by <code class="docutils literal notranslate"><span class="pre">n</span></code> (defaults to 1) records. Works for
formatted and unformatted files.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>n</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">backspace</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.close">
<code class="descname">close</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.close" title="Permalink to this definition">¶</a></dt>
<dd><p>Close file but don’t finalise this Inoutput</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_close</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.deactivate">
<code class="descname">deactivate</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.deactivate" title="Permalink to this definition">¶</a></dt>
<dd><p>inoutput_deactivate</p>
<p>Deactivate an Inoutput object temporarily.</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">deactivate</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.do_output">
<code class="descname">do_output</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.do_output" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_inoutput_do_output</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_do_output</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.mpi_all_inoutput">
<code class="descname">mpi_all_inoutput</code><span class="sig-paren">(</span><span class="optional">[</span><em>value</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.mpi_all_inoutput" title="Permalink to this definition">¶</a></dt>
<dd><p>inoutput_mpi_all_inoutput([value])</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>value</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">mpi_all_inoutput</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.parse_line">
<code class="descname">parse_line</code><span class="sig-paren">(</span><em>delimiters</em>, <em>fields</em><span class="optional">[</span>, <em>status</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.parse_line" title="Permalink to this definition">¶</a></dt>
<dd><p>Call parse_string on the next line from a file</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>delimiters</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘S’) with bounds (qp_n0,(*))</span></dt>
<dd></dd>
<dt><strong>status</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>num_fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">parse_line</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.print_mem_info">
<code class="descname">print_mem_info</code><span class="sig-paren">(</span><span class="optional">[</span><em>file</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.print_mem_info" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>file</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">inoutput</span></code> object, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">print_mem_info</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.print_mpi_id">
<code class="descname">print_mpi_id</code><span class="sig-paren">(</span><span class="optional">[</span><em>value</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.print_mpi_id" title="Permalink to this definition">¶</a></dt>
<dd><p>inoutput_print_mpi_id([value])</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>value</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">print_mpi_id</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.read_ascii">
<code class="descname">read_ascii</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.read_ascii" title="Permalink to this definition">¶</a></dt>
<dd><p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">read_ascii</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">read_ascii</code><span class="sig-paren">(</span><em>n0</em><span class="optional">[</span>, <em>status</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><p>Read scalar and array data from ascii files. These
interfaces are not yet heavily overloaded to cater for all intrinsic and most
derived types.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_da,0)</li>
<li><strong>status</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>da</strong> –  rank-1 array(‘d’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">reada_real_dim1</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">read_ascii</code><span class="sig-paren">(</span><em>n0</em><span class="optional">[</span>, <em>status</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ia,0)</li>
<li><strong>status</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ia</strong> –  rank-1 array(‘i’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">reada_int_dim1</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.read_line">
<code class="descname">read_line</code><span class="sig-paren">(</span><span class="optional">[</span><em>status</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.read_line" title="Permalink to this definition">¶</a></dt>
<dd><p>Read a line of text from a file (up to a line break, or 1024 characters).
This can then be parsed by the calling routine (using <code class="docutils literal notranslate"><span class="pre">parse_line</span></code> for example)</p>
<p>Optionally, a status is returned which is:</p>
<p>begin{itemize}
item <span class="math notranslate nohighlight">\(&lt;0\)</span> if the end of the file is reached
item <span class="math notranslate nohighlight">\(=0\)</span> if no problems were encountered
item <span class="math notranslate nohighlight">\(&gt;0\)</span> if there was a read error
end{itemize}</p>
<p>The actual number returned is implementation specific</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>status</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_inoutput_read_line</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">read_line</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.system.InOutput.rewind">
<code class="descname">rewind</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.InOutput.rewind" title="Permalink to this definition">¶</a></dt>
<dd><p>Rewind to the start of this file. Works for both formatted and unformatted files.</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">rewind</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.system.InOutput.active">
<code class="descname">active</code><a class="headerlink" href="#quippy.system.InOutput.active" title="Permalink to this definition">¶</a></dt>
<dd><p>Does it print?</p>
</dd></dl>

</dd></dl>

<dl class="function">
<dt id="quippy.system.find_closing_delimiter">
<code class="descclassname">quippy.system.</code><code class="descname">find_closing_delimiter</code><span class="sig-paren">(</span><em>closing_delim</em>, <em>opening_delims</em>, <em>closing_delims</em>, <em>matching</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.find_closing_delimiter" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>closing_delim</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>opening_delims</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>closing_delims</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>matching</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">find_closing_delimiter</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.pick_up_unit">
<code class="descclassname">quippy.system.</code><code class="descname">pick_up_unit</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.pick_up_unit" title="Permalink to this definition">¶</a></dt>
<dd><p>OMIT</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_unit</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">pick_up_unit</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_resync_rng">
<code class="descclassname">quippy.system.</code><code class="descname">system_resync_rng</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_resync_rng" title="Permalink to this definition">¶</a></dt>
<dd><p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_resync_rng</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.upper_case">
<code class="descclassname">quippy.system.</code><code class="descname">upper_case</code><span class="sig-paren">(</span><em>word</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.upper_case" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert a word to upper case</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>word</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_upper_case</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">upper_case</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_mpi_size_rank">
<code class="descclassname">quippy.system.</code><code class="descname">get_mpi_size_rank</code><span class="sig-paren">(</span><em>comm</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_mpi_size_rank" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the mpi size and rank for the communicator <code class="docutils literal notranslate"><span class="pre">comm</span></code>.
this routine aborts of _MPI is not defined</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>comm</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">MPI communicator</p>
</dd>
<dt><strong>nproc</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd><p class="first last">Total number of processes</p>
</dd>
<dt><strong>rank</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd><p class="first last">Rank of this process</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_mpi_size_rank</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_timer">
<code class="descclassname">quippy.system.</code><code class="descname">system_timer</code><span class="sig-paren">(</span><em>name</em><span class="optional">[</span>, <em>do_always</em>, <em>time_elapsed</em>, <em>do_print</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_timer" title="Permalink to this definition">¶</a></dt>
<dd><p>Measure elapsed CPU and wall clock time between pairs of calls with
matching <code class="docutils literal notranslate"><span class="pre">name</span></code> parameter. Calls to <code class="docutils literal notranslate"><span class="pre">system_timer</span></code> must be properly
nested (i.e. start and stop from different pairs can’t overlap), and
maximum depth of calls is set by the <code class="docutils literal notranslate"><span class="pre">TIMER_STACK</span></code> parameter.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>  <span class="n">call</span> <span class="n">system_timer</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>  <span class="n">start</span> <span class="n">the</span> <span class="n">clock</span>
  <span class="o">...</span>                      <span class="n">do</span> <span class="n">something</span>
  <span class="n">call</span> <span class="n">system_timer</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>  <span class="n">stop</span> <span class="n">clock</span> <span class="ow">and</span> <span class="nb">print</span> <span class="n">elapsed</span> <span class="n">time</span>

<span class="n">If</span> <span class="n">optional</span> <span class="n">do_always</span> <span class="n">argument</span> <span class="ow">is</span> <span class="n">true</span><span class="p">,</span> <span class="n">routine</span> <span class="n">will</span> <span class="n">do</span> <span class="n">its</span> <span class="n">thing</span> <span class="n">even</span>
<span class="k">if</span> <span class="n">system_do_timing</span> <span class="ow">is</span> <span class="n">false</span><span class="o">.</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>name</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd><p class="first last">Unique identifier for this timer</p>
</dd>
<dt><strong>do_always</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>time_elapsed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(float,’d’), optional</span></dt>
<dd></dd>
<dt><strong>do_print</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_timer</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_of_str">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_of_str</code><span class="sig-paren">(</span><em>str</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_of_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Map from descriptive verbosity names (<code class="docutils literal notranslate"><span class="pre">NORMAL</span></code>, <code class="docutils literal notranslate"><span class="pre">VERBOSE</span></code> etc.) to numbers</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_val</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_of_str</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.reference_true">
<code class="descclassname">quippy.system.</code><code class="descname">reference_true</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.reference_true" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_reference_true</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">reference_true</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.th">
<code class="descclassname">quippy.system.</code><code class="descname">th</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.th" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the correct ordinal ending (st,nd,rd,th) for the given integer</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>n</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_th</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=2)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">th</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.next_non_separator">
<code class="descclassname">quippy.system.</code><code class="descname">next_non_separator</code><span class="sig-paren">(</span><em>start</em>, <em>end</em>, <em>separators</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.next_non_separator" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>start</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>end</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>separators</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>dist</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
<dt><strong>ret_c</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">next_non_separator</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.hello_world">
<code class="descclassname">quippy.system.</code><code class="descname">hello_world</code><span class="sig-paren">(</span><span class="optional">[</span><em>seed</em>, <em>common_seed</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.hello_world" title="Permalink to this definition">¶</a></dt>
<dd><p>Called by <code class="docutils literal notranslate"><span class="pre">system_initialise</span></code> to print welcome messages and
seed the random number generator.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Seed for the random number generator.</p>
</dd>
<dt><strong>common_seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">If <code class="docutils literal notranslate"><span class="pre">common_seed</span></code> is true (default), random seed will be the same for each
MPI process.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">hello_world</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_env_var">
<code class="descclassname">quippy.system.</code><code class="descname">get_env_var</code><span class="sig-paren">(</span><em>name</em><span class="optional">[</span>, <em>status</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_env_var" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>name</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>status</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>arg</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_env_var</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.ran_exp">
<code class="descclassname">quippy.system.</code><code class="descname">ran_exp</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.ran_exp" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a random real distributed exponentially between zero and positive infinity
with mean and variance of unity</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_r</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">ran_exp</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.parse_string">
<code class="descclassname">quippy.system.</code><code class="descname">parse_string</code><span class="sig-paren">(</span><em>delimiters</em>, <em>fields</em><span class="optional">[</span>, <em>matching</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.parse_string" title="Permalink to this definition">¶</a></dt>
<dd><p>outdated - please use split_string
Parse a string into fields delimited by certain characters. On exit
the <code class="docutils literal notranslate"><span class="pre">fields</span></code> array will contain one field per entry and <code class="docutils literal notranslate"><span class="pre">num_fields</span></code>
gives the total number of fields. <code class="docutils literal notranslate"><span class="pre">status</span></code> will be given the error status
(if present) and so can be used to tell if an end-of-file occurred.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>delimiters</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘S’) with bounds (qp_n0,(*))</span></dt>
<dd></dd>
<dt><strong>matching</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>num_fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">parse_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.parse_string_orig">
<code class="descclassname">quippy.system.</code><code class="descname">parse_string_orig</code><span class="sig-paren">(</span><em>delimiters</em>, <em>fields</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.parse_string_orig" title="Permalink to this definition">¶</a></dt>
<dd><p>Parse a string into fields delimited by certain characters. On exit
the <code class="docutils literal notranslate"><span class="pre">fields</span></code> array will contain one field per entry and <code class="docutils literal notranslate"><span class="pre">num_fields</span></code>
gives the total number of fields. <code class="docutils literal notranslate"><span class="pre">status</span></code> will be given the error status
(if present) and so can be used to tell if an end-of-file occurred.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>delimiters</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘S’) with bounds (qp_n0,(*))</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>num_fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">parse_string_orig</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_initialise">
<code class="descclassname">quippy.system.</code><code class="descname">system_initialise</code><span class="sig-paren">(</span><span class="optional">[</span><em>verbosity</em>, <em>seed</em>, <em>mpi_all_inoutput</em>, <em>common_seed</em>, <em>enable_timing</em>, <em>quippy_running</em>, <em>mainlog_file</em>, <em>mainlog_unit</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_initialise" title="Permalink to this definition">¶</a></dt>
<dd><p>Must be called at the start of all programs. Initialises MPI if present,
set the random number seed sets up the default Inoutput objects
logger and errorlog to point to stdout and stderr respectively. Calls
Hello_World to do some of the work and print a friendly welcome. If we’re
using MPI, by default we set the same random seed for each process.
This also attempts to read the executable name, the number of command
arguments, and the arguments themselves.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">mainlog output verbosity</p>
</dd>
<dt><strong>seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Seed for the random number generator.</p>
</dd>
<dt><strong>mpi_all_inoutput</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Print on all MPI nodes (false by default)</p>
</dd>
<dt><strong>common_seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>enable_timing</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Enable system_timer() calls</p>
</dd>
<dt><strong>quippy_running</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">.true. if running under quippy (Python interface)</p>
</dd>
<dt><strong>mainlog_file</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>mainlog_unit</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">If <code class="docutils literal notranslate"><span class="pre">common_seed</span></code> is true (default), random seed will be the same for each
MPI process.</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_initialise</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_pop">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_pop</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_pop" title="Permalink to this definition">¶</a></dt>
<dd><p>pop the current verbosity value off the stack</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_pop</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_quippy_running">
<code class="descclassname">quippy.system.</code><code class="descname">get_quippy_running</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_quippy_running" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_get_quippy_running</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_quippy_running</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.round">
<code class="descclassname">quippy.system.</code><code class="descname">round</code><span class="sig-paren">(</span><em>r</em>, <em>digits</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.round" title="Permalink to this definition">¶</a></dt>
<dd><p>Concatenation functions.
Overloadings for the // operator to make strings from various other types.
In each case, we need to work out the exact length of the resultant string
in order to avoid printing excess spaces.
Return a string which is the real number <code class="docutils literal notranslate"><span class="pre">r</span></code> rounded to <code class="docutils literal notranslate"><span class="pre">digits</span></code> decimal digits</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>r</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>digits</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_round</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">round</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_get_random_seed">
<code class="descclassname">quippy.system.</code><code class="descname">system_get_random_seed</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_get_random_seed" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the current random number seed.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_system_get_random_seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_get_random_seed</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.set_timing">
<code class="descclassname">quippy.system.</code><code class="descname">set_timing</code><span class="sig-paren">(</span><em>do_timing</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.set_timing" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>do_timing</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">set_timing</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.real_sci_format_length">
<code class="descclassname">quippy.system.</code><code class="descname">real_sci_format_length</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.real_sci_format_length" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_len</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">real_sci_format_length</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.enable_timing">
<code class="descclassname">quippy.system.</code><code class="descname">enable_timing</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.enable_timing" title="Permalink to this definition">¶</a></dt>
<dd><p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">enable_timing</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.mem_info">
<code class="descclassname">quippy.system.</code><code class="descname">mem_info</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.mem_info" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>total_mem</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
<dt><strong>free_mem</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">mem_info</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.link_run_directory">
<code class="descclassname">quippy.system.</code><code class="descname">link_run_directory</code><span class="sig-paren">(</span><em>sourcename</em><span class="optional">[</span>, <em>basename</em>, <em>run_dir_i</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.link_run_directory" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>sourcename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>basename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>run_dir_i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_dir</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">link_run_directory</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.ran_uniform">
<code class="descclassname">quippy.system.</code><code class="descname">ran_uniform</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.ran_uniform" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a random real number uniformly distributed in the range [0,1]</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_ran_uniform</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">ran_uniform</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.mpi_id">
<code class="descclassname">quippy.system.</code><code class="descname">mpi_id</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.mpi_id" title="Permalink to this definition">¶</a></dt>
<dd><p>Return this processes’ MPI ID</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_id</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">mpi_id</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.progress">
<code class="descclassname">quippy.system.</code><code class="descname">progress</code><span class="sig-paren">(</span><em>total</em>, <em>current</em>, <em>name</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.progress" title="Permalink to this definition">¶</a></dt>
<dd><p>Print a progress bar</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>total</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>current</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>name</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">progress</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.linebreak_string">
<code class="descclassname">quippy.system.</code><code class="descname">linebreak_string</code><span class="sig-paren">(</span><em>str</em>, <em>line_len</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.linebreak_string" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>line_len</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_lb_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">linebreak_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_finalise">
<code class="descclassname">quippy.system.</code><code class="descname">system_finalise</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_finalise" title="Permalink to this definition">¶</a></dt>
<dd><p>Shut down gracefully, finalising system objects.</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_finalise</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.print_title">
<code class="descclassname">quippy.system.</code><code class="descname">print_title</code><span class="sig-paren">(</span><em>title</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.print_title" title="Permalink to this definition">¶</a></dt>
<dd><p>Print a centred title, like this:</p>
<p><code class="docutils literal notranslate"><span class="pre">====================================</span> <span class="pre">Title</span> <span class="pre">=====================================</span></code></p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>title</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">print_title</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.wait_for_file_to_exist">
<code class="descclassname">quippy.system.</code><code class="descname">wait_for_file_to_exist</code><span class="sig-paren">(</span><em>filename</em>, <em>max_wait_time</em><span class="optional">[</span>, <em>cycle_time</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.wait_for_file_to_exist" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>filename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>max_wait_time</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
<dt><strong>cycle_time</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float, optional</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">wait_for_file_to_exist</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.string_to_logical">
<code class="descclassname">quippy.system.</code><code class="descname">string_to_logical</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.string_to_logical" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert an input string into a logical.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>string</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_string_to_logical</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_logical</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.split_string">
<code class="descclassname">quippy.system.</code><code class="descname">split_string</code><span class="sig-paren">(</span><em>separators</em>, <em>quotes</em>, <em>fields</em><span class="optional">[</span>, <em>matching</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.split_string" title="Permalink to this definition">¶</a></dt>
<dd><p>split a string at separators, making sure not to break up bits that
are in quotes (possibly matching opening and closing quotes), and
also strip one level of quotes off, sort of like a shell would when
tokenizing</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>separators</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>quotes</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-2 array(‘S’) with bounds (qp_n0,(*))</span></dt>
<dd></dd>
<dt><strong>matching</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>num_fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">split_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_to_str">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_to_str</code><span class="sig-paren">(</span><em>val</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_to_str" title="Permalink to this definition">¶</a></dt>
<dd><p>Map from verbsoity codes to descriptive strings</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>val</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=10)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_to_str</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.string_to_int">
<code class="descclassname">quippy.system.</code><code class="descname">string_to_int</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.string_to_int" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert an input string into an integer.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>string</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_string_to_int</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_int</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.real_format_length">
<code class="descclassname">quippy.system.</code><code class="descname">real_format_length</code><span class="sig-paren">(</span><em>r</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.real_format_length" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>r</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_len</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">real_format_length</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.alloc_trace">
<code class="descclassname">quippy.system.</code><code class="descname">alloc_trace</code><span class="sig-paren">(</span><em>str</em>, <em>amt</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.alloc_trace" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>amt</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">alloc_trace</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.parallel_print">
<code class="descclassname">quippy.system.</code><code class="descname">parallel_print</code><span class="sig-paren">(</span><em>lines</em>, <em>comm</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.parallel_print" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>lines</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-2 array(‘S’) with bounds (qp_n0,(*))</span></dt>
<dd></dd>
<dt><strong>comm</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>file</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">parallel_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_set_minimum">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_set_minimum</code><span class="sig-paren">(</span><em>verbosity</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_set_minimum" title="Permalink to this definition">¶</a></dt>
<dd><p>set the minimum verbosity value, by pushing value onto
stack and pushing 1 on to verbosity_cascade_stack</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_set_minimum</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.current_version">
<code class="descclassname">quippy.system.</code><code class="descname">current_version</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.current_version" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_current_version</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">current_version</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.increase_stack">
<code class="descclassname">quippy.system.</code><code class="descname">increase_stack</code><span class="sig-paren">(</span><em>stack_size</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.increase_stack" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>stack_size</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_increase_stack</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">increase_stack</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.current_verbosity">
<code class="descclassname">quippy.system.</code><code class="descname">current_verbosity</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.current_verbosity" title="Permalink to this definition">¶</a></dt>
<dd><p>return the current value of verbosity</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_current_verbosity</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">current_verbosity</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_push_decrement">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_push_decrement</code><span class="sig-paren">(</span><span class="optional">[</span><em>n</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_push_decrement" title="Permalink to this definition">¶</a></dt>
<dd><p>push the current value - n onto the stack</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>n</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_push_decrement</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.progress_timer">
<code class="descclassname">quippy.system.</code><code class="descname">progress_timer</code><span class="sig-paren">(</span><em>total</em>, <em>current</em>, <em>name</em>, <em>elapsed_seconds</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.progress_timer" title="Permalink to this definition">¶</a></dt>
<dd><p>Print a progress bar with an estimate of time to completion
based on the elapsed time so far</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>total</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>current</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>name</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>elapsed_seconds</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">progress_timer</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.reference_false">
<code class="descclassname">quippy.system.</code><code class="descname">reference_false</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.reference_false" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_reference_false</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">reference_false</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.cmd_arg_count">
<code class="descclassname">quippy.system.</code><code class="descname">cmd_arg_count</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.cmd_arg_count" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_cmd_arg_count</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">cmd_arg_count</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.abort_on_mpi_error">
<code class="descclassname">quippy.system.</code><code class="descname">abort_on_mpi_error</code><span class="sig-paren">(</span><em>error_code</em>, <em>routine_name</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.abort_on_mpi_error" title="Permalink to this definition">¶</a></dt>
<dd><p>Abort with a useful message if an MPI routine returned an error status</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>error_code</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>routine_name</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">abort_on_mpi_error</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.linebreak_string_length">
<code class="descclassname">quippy.system.</code><code class="descname">linebreak_string_length</code><span class="sig-paren">(</span><em>str</em>, <em>line_len</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.linebreak_string_length" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>line_len</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_length</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">linebreak_string_length</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.print_warning">
<code class="descclassname">quippy.system.</code><code class="descname">print_warning</code><span class="sig-paren">(</span><em>message</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.print_warning" title="Permalink to this definition">¶</a></dt>
<dd><p>Print a warning message to log</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>message</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">print_warning</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_cmd_arg">
<code class="descclassname">quippy.system.</code><code class="descname">get_cmd_arg</code><span class="sig-paren">(</span><em>i</em><span class="optional">[</span>, <em>status</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_cmd_arg" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>status</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>arg</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_cmd_arg</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.ran_string">
<code class="descclassname">quippy.system.</code><code class="descname">ran_string</code><span class="sig-paren">(</span><em>l</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.ran_string" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a random string of length l containing the characters A-Z, a-z, and 0-9</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>l</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_ran_string</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">ran_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_unset_minimum">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_unset_minimum</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_unset_minimum" title="Permalink to this definition">¶</a></dt>
<dd><p>unset the minimum verbosity value, by popping value from
stack and popping from verbosity_cascade_stack</p>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_unset_minimum</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_mainlog_errorlog_ptr">
<code class="descclassname">quippy.system.</code><code class="descname">get_mainlog_errorlog_ptr</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_mainlog_errorlog_ptr" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>mainlog_ptr</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-1 array(‘i’) with bounds (2)</span></dt>
<dd></dd>
<dt><strong>errorlog_ptr</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-1 array(‘i’) with bounds (2)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_mainlog_errorlog_ptr</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_push_increment">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_push_increment</code><span class="sig-paren">(</span><span class="optional">[</span><em>n</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_push_increment" title="Permalink to this definition">¶</a></dt>
<dd><p>push the current value + n onto the stack</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>n</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_push_increment</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_reseed_rng">
<code class="descclassname">quippy.system.</code><code class="descname">system_reseed_rng</code><span class="sig-paren">(</span><em>new_seed</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_reseed_rng" title="Permalink to this definition">¶</a></dt>
<dd><p>Reseed the random number generator. Useful when restarting from check files.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>new_seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_reseed_rng</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.mpi_n_procs">
<code class="descclassname">quippy.system.</code><code class="descname">mpi_n_procs</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.mpi_n_procs" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the total number of MPI processes.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_n</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">mpi_n_procs</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.ran">
<code class="descclassname">quippy.system.</code><code class="descname">ran</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.ran" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a random integer</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_dran</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">ran</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.lower_case">
<code class="descclassname">quippy.system.</code><code class="descname">lower_case</code><span class="sig-paren">(</span><em>word</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.lower_case" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert a word to lower case</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>word</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_lower_case</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">lower_case</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.system_set_random_seeds">
<code class="descclassname">quippy.system.</code><code class="descname">system_set_random_seeds</code><span class="sig-paren">(</span><em>seed</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.system_set_random_seeds" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>seed</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">system_set_random_seeds</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.s2a">
<code class="descclassname">quippy.system.</code><code class="descname">s2a</code><span class="sig-paren">(</span><em>s</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.s2a" title="Permalink to this definition">¶</a></dt>
<dd><p>String to character array</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>s</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_a</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-2 array(‘S’) with bounds (slen(qp_s),(1))</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">s2a</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.verbosity_push">
<code class="descclassname">quippy.system.</code><code class="descname">verbosity_push</code><span class="sig-paren">(</span><em>val</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.verbosity_push" title="Permalink to this definition">¶</a></dt>
<dd><p>Push a value onto the verbosity stack
Don’t ever lower the verbosity if verbosity minimum is set,</p>
<blockquote>
<div>but always push _something_</div></blockquote>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>val</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">verbosity_push</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.int_format_length">
<code class="descclassname">quippy.system.</code><code class="descname">int_format_length</code><span class="sig-paren">(</span><em>i</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.int_format_length" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_len</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">int_format_length</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.pad">
<code class="descclassname">quippy.system.</code><code class="descname">pad</code><span class="sig-paren">(</span><em>s</em>, <em>l</em>, <em>n0</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.pad" title="Permalink to this definition">¶</a></dt>
<dd><p>String to padded character array of length l</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>s</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>l</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>n0</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">shape(qp_ret_a,0)</p>
</dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_a</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-2 array(‘S’) with bounds (qp_n0,(1))</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">pad</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.dealloc_trace">
<code class="descclassname">quippy.system.</code><code class="descname">dealloc_trace</code><span class="sig-paren">(</span><em>str</em>, <em>amt</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.dealloc_trace" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>amt</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">dealloc_trace</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.string_to_real">
<code class="descclassname">quippy.system.</code><code class="descname">string_to_real</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.string_to_real" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert an input string into a real.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>string</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_string_to_real</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_real</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.a2s">
<code class="descclassname">quippy.system.</code><code class="descname">a2s</code><span class="sig-paren">(</span><em>a</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.a2s" title="Permalink to this definition">¶</a></dt>
<dd><p>Character array to string</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>a</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-2 array(‘S’) with bounds (qp_n0,(1))</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_s</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">a2s</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.date_and_time_string">
<code class="descclassname">quippy.system.</code><code class="descname">date_and_time_string</code><span class="sig-paren">(</span><em>values</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.date_and_time_string" title="Permalink to this definition">¶</a></dt>
<dd><p>Take the values from <code class="docutils literal notranslate"><span class="pre">date_and_time</span></code> and make a nice string</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>values</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (8)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_date_and_time_string</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=21)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">date_and_time_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.get_timing">
<code class="descclassname">quippy.system.</code><code class="descname">get_timing</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.get_timing" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_get_timing</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">get_timing</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.disable_timing">
<code class="descclassname">quippy.system.</code><code class="descname">disable_timing</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.disable_timing" title="Permalink to this definition">¶</a></dt>
<dd><p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">disable_timing</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.split_string_simple">
<code class="descclassname">quippy.system.</code><code class="descname">split_string_simple</code><span class="sig-paren">(</span><em>str</em>, <em>separators</em>, <em>n0</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.split_string_simple" title="Permalink to this definition">¶</a></dt>
<dd><p>split a string into fields separated by possible separators
no quoting, matching separators, just a simple split</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>str</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd><p class="first last">string to be split</p>
</dd>
<dt><strong>fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">rank-2 array(‘S’) with bounds (qp_n0,(1024))</span></dt>
<dd><p class="first last">on return, array of fields</p>
</dd>
<dt><strong>n0</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd><p class="first last">shape(qp_fields,0)</p>
</dd>
<dt><strong>n_fields</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd><p class="first last">on return, number of fields</p>
</dd>
<dt><strong>separators</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd><p class="first last">string of possible separators</p>
</dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">split_string_simple</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.is_file_readable">
<code class="descclassname">quippy.system.</code><code class="descname">is_file_readable</code><span class="sig-paren">(</span><em>filename</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.is_file_readable" title="Permalink to this definition">¶</a></dt>
<dd><p>Test if the file <code class="docutils literal notranslate"><span class="pre">filename</span></code> can be accessed.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>filename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_is_file_readable</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">is_file_readable</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.current_times">
<code class="descclassname">quippy.system.</code><code class="descname">current_times</code><span class="sig-paren">(</span><span class="optional">[</span><em>cpu_t</em>, <em>wall_t</em>, <em>mpi_t</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.current_times" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>cpu_t</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(float,’d’), optional</span></dt>
<dd></dd>
<dt><strong>wall_t</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(float,’d’), optional</span></dt>
<dd></dd>
<dt><strong>mpi_t</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(float,’d’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">current_times</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.ran_normal">
<code class="descclassname">quippy.system.</code><code class="descname">ran_normal</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.ran_normal" title="Permalink to this definition">¶</a></dt>
<dd><p>Return random real from Normal distribution with mean zero and standard deviation one.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_ran_normal</strong> <span class="classifier-delimiter">:</span> <span class="classifier">float</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">ran_normal</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.make_run_directory">
<code class="descclassname">quippy.system.</code><code class="descname">make_run_directory</code><span class="sig-paren">(</span><span class="optional">[</span><em>basename</em>, <em>force_run_dir_i</em>, <em>run_dir_i</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.make_run_directory" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>basename</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input string(len=-1), optional</span></dt>
<dd></dd>
<dt><strong>force_run_dir_i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>run_dir_i</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_dir</strong> <span class="classifier-delimiter">:</span> <span class="classifier">string(len=1024)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">make_run_directory</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt id="quippy.system.optional_default">
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.optional_default" title="Permalink to this definition">¶</a></dt>
<dd><p>takes as arguments a default value and an optional argument, and
returns the optional argument value if it’s present, otherwise
the default value</p>
<p>Routine is wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">optional_default</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input float</em>) – </li>
<li><strong>opt_val</strong> (<em>input float</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_r</strong> –  float</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_r</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input int</em>) – </li>
<li><strong>opt_val</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_l</strong> –  int</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_l</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input int</em>) – </li>
<li><strong>opt_val</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_i</strong> –  int</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_i</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>opt_val</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_c</strong> –  string(len=1024)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_c</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>opt_val</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>size</em><em>(</em><em>qp_def</em><em>)</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_ia</strong> –  rank-1 array(‘i’) with bounds (size(qp_def))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_ia</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>opt_val</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>size</em><em>(</em><em>qp_def</em><em>)</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_ra</strong> –  rank-1 array(‘d’) with bounds (size(qp_def))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_ra</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">optional_default</code><span class="sig-paren">(</span><em>def</em><span class="optional">[</span>, <em>opt_val</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>def</strong> (<em>input rank-2 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>(</em><em>*</em><em>)</em><em>)</em>) – </li>
<li><strong>opt_val</strong> (<em>input rank-2 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n1</em><em>,</em><em>(</em><em>*</em><em>)</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_optional_default_ca</strong> –  rank-2 array(‘S’) with bounds (size(qp_def),(1024))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">optional_default_ca</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="function">
<dt id="quippy.system.string_to_numerical">
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.string_to_numerical" title="Permalink to this definition">¶</a></dt>
<dd><p>Routine is wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">string_to_numerical</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em>, <em>n0</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_real1d,0)</li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>real1d</strong> –  rank-1 array(‘d’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_real1d</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>integer_number</strong> –  int</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_integer_sub</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>real_number</strong> –  float</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_real_sub</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em>, <em>n0</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_integer1d,0)</li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>integer1d</strong> –  rank-1 array(‘i’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_integer1d</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em>, <em>n0</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_logical1d,0)</li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>logical1d</strong> –  rank-1 array(‘i’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_logical1d</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">string_to_numerical</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>logical_number</strong> –  int</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">string_to_logical_sub</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="function">
<dt id="quippy.system.print_">
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.system.print_" title="Permalink to this definition">¶</a></dt>
<dd><p>Overloaded interface for printing. With the
‘this’ parameter omitted output goes to the default mainlog (‘stdout’). The
‘verbosity’ parameter controls whether the object is actually printed;
if the verbosity is greater than that currently at the top of the
verbosity stack then output is suppressed. Possible verbosity levels
range from ‘ERROR’ through ‘NORMAL’, ‘VERBOSE’, ‘NERD’ and ‘ANAL’.
Other user-defined types define the Print interface in the same way.</p>
<p>Routine is wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">print_</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>int</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>int</strong> (<em>input int</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_print_integer</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>string</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em>, <em>nocr</em>, <em>do_flush</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>string</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional) – </li>
<li><strong>nocr</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>do_flush</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_print_string</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>char_a</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>char_a</strong> (<em>input rank-2 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>(</em><em>*</em><em>)</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_print_char_array</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>log</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>log</strong> (<em>input int</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_print_logical</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>real</em><span class="optional">[</span>, <em>verbosity</em>, <em>file</em>, <em>precision</em>, <em>format</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>real</strong> (<em>input float</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object, optional) – </li>
<li><strong>precision</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>format</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">inoutput_print_real</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/System.f95">src/libAtoms/System.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">int_matrix_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'D'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">matrix_z_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">logical_matrix_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">logical_array_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">vector_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'D'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">matrix_z_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'D'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">vector_z_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">int_matrix_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">integer_array_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">matrix_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">vector_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">logical_array_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">logical_matrix_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'D'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">vector_z_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em><span class="optional">[</span>, <em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">integer_array_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descclassname">quippy.system.</code><code class="descname">print_</code><span class="sig-paren">(</span><em>this</em>, <em>file</em><span class="optional">[</span>, <em>verbosity</em>, <em>always</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>this</strong> (<em>input rank-2 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </li>
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
<li><strong>always</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">matrix_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/linearalgebra.f95">src/libAtoms/linearalgebra.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

</div>


           </div>
           
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
      
        <a href="units.html" class="btn btn-neutral float-left" title="Units and physical constants" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2008-2016, James Kermode

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script>

  
  
    
   

</body>
</html>